#include "lib.h"

#include "ATL.h"

#include "FlotMessage.h"

#include <algorithm>

#include <boost/algorithm/string/replace.hpp>

using namespace std;
using namespace boost::algorithm;

/******************************************************************************
 *
 * Définition des fonctions
 *
 *****************************************************************************/

int puissance( const int & a, const unsigned & b )
{
    if ( b == 0 )
        return 1;
    else return b % 2 == 0 ?
                puissance( a * a, b / 2 ) :
                a * puissance( a * a, b / 2 );
}

unsigned digit( const int& a, const int& b )
{
    return ( a / puissance( 10, b ) ) % 10;
}

unsigned demanderUnsigned( const string& question )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "demanderUnsigned -> début" << endmsg;

    bool encore( false );
    unsigned retour;
    string poubelle;

    do
    {
        mess << BLANK << question << endaff;
        cin >> retour;

        encore = cin.fail();

        if ( encore )
        {
            mess << WARN << endmsg << "Entrer un nombre entier positif!"
                 << endmsg;
            cin.clear();
            getline( cin, poubelle );
        }
    }
    while( encore );

    mess << FUNC << "demanderUnsigned -> fin" << endmsg;
    return retour;
}

unsigned demanderUnsignedBorne( const string& question,
                                const unsigned& min,
                                const unsigned& max )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "demanderUnsignedBorne -> début" << endmsg;

    unsigned nbr;
    bool encore( false );

    do
    {
        nbr = demanderUnsigned(question);

        encore = ( nbr < min || nbr > max );

        if ( encore )
        {
            mess << WARN << "Entrer un nombre entier entre " << min
                 << " et " << max << " !" << endmsg;
        }
    }
    while( encore );

    mess << FUNC << "demanderUnsignedBorne -> fin" << endmsg;
    return nbr;
}

string afficheAccent( const string& brut )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "afficheAccent -> début" << endmsg;

    string retour(brut);
    mess << LFUNC << retour << " -> " <<endaff;
    replace_all( retour, "\\'e", "é" );
    mess << LFUNC << retour << endmsg;
    mess << LFUNC << retour << " -> " <<endaff;
    replace_all( retour, "\\`a", "à" );
    mess << LFUNC << retour << endmsg;
    mess << LFUNC << retour << " -> " <<endaff;
    replace_all( retour, "\\^o", "ô" );
    mess << LFUNC << retour << endmsg;

    mess << FUNC << "afficheAccent -> fin" << endmsg;

    return retour;
}

bool safePushBack( vector< unsigned > *ptr, const unsigned& valeur )
{
    FlotMessage& mess = flotMessageGlobal();

    mess << FUNC << "safePushBack -> début" << endmsg;

    vector< unsigned >::iterator loc, Begin(ptr -> begin()), End(ptr -> end());

    if ( Begin == End )
        return false;

    loc = find( Begin, End, valeur );

    mess << DEBUG << "Position : " << unsigned( loc - Begin )
         << " sur une taille de " << ptr -> size() << endmsg;


    mess << FUNC << "safePushBack -> fin" << endmsg;

    return !( loc == End );
}

bool safePushBack( vector< unsigned > *ptr, const unsigned& valeur,
                   vector< unsigned >& sauter )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "safePushBack -> début" << endmsg;

    vector< unsigned >::iterator loc, Begin(ptr -> begin()), End(ptr -> end()),
            sBegin(sauter.begin()), sEnd(sauter.end()), sIt, fBegin;
    bool retour( true );
    fBegin = Begin;

    if ( Begin == End )
        return false;

    // Si le vecteur d'emplacement à éviter est vide, alors on appelle
    // la méthode basique.
    if ( sBegin == sEnd )
    {
        mess << FUNC << "safePushBack -> fin" << endmsg;
        return safePushBack( ptr, valeur );
    }

    do
    {
        loc = find( fBegin, End, valeur );
        if ( loc == End )
        {
            retour = false;
            break;
        }
        mess << DEBUG << "A chercher : " << unsigned( loc - Begin ) << endmsg;
        sIt = find( sBegin, sEnd, unsigned( loc - Begin ) );
        if ( sIt != sEnd )
        {
            retour = false;
            fBegin = ++loc;
        }
        else
        {
            retour = true;
            break;
        }
    }
    while( loc != End );

    mess << DEBUG << "Position : " << unsigned( loc - Begin )
         << " sur une taille de " << ptr -> size() << endmsg;

    mess << FUNC << "safePushBack -> fin" << endmsg;

    return retour;
}

void gererEspacesBlancs( char* tab[], int& nbr,
                         vector< string >& retour )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "gererEspacesBlancs -> début" << endmsg;

    retour.clear();
    for ( unsigned i( 0u ); i < static_cast< unsigned >( nbr ); i++ )
    {
        retour.push_back( tab[ i ] );
        mess << DEBUG << retour.back() << endmsg;
    }

    mess << DEBUG << endmsg;

    vector<string>::iterator it, Begin(++retour.begin()), End(retour.end());

    for ( it = ++Begin; it != retour.end(); it++ )
    {
        if ( (*it)[ 0u ] < 48 || (*it)[ 0u ] > 57 )
        {
            *( it - 1 ) += "\\ " + *it;
            retour.erase(it);
            mess << DEBUG << "Fusion en " << *( it -1 ) << endmsg;
            it--;
        }
    }

    mess << DEBUG << endmsg;

    size_t loc( retour[ 1u ].find( "\'" ) );
    if ( loc != string::npos )
        retour[1].replace( loc, 1, "\\'" );

    nbr = retour.size();

    mess << FUNC << "gererEspacesBlancs -> fin" << endmsg;
}

bool lireVectorUInt( const string& donnees, vector< unsigned > *vec )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "lireVectorUInt -> début" << endmsg;

    vec -> clear();

    size_t taille( donnees.size() ), i( 0u );

    mess << LINFO << "Vecteur complet " << donnees << endmsg;

    string tmp;

    unsigned nbr;

    for ( i = 0u; i < taille; i++ )
    {
        while  ( donnees[ i ] == ' ' && i < taille )
            i++;
        tmp = "";
        while ( donnees[ i ] != ' ' && i < taille )
        {
            tmp += donnees[ i ];
            i++;
        }

        mess << LINFO << "Valeur à convertir : " << tmp << endmsg;

        if ( ! lireString( tmp, nbr ) )
        {
            mess << ERR << "Ne peut pas convertir " << tmp << endmsg;
            mess << FUNC << "lireVectorUInt -> fin" << endmsg;
            return false;
        }
        vec -> push_back( nbr );
    }

    mess << FUNC << "lireVectorUInt -> fin" << endmsg;
    return true;
}

void determinerScoresAjustes( const string& race, const unsigned& dext,
                              vector< int >*& ptr )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "determinerScoresAjustes -> début" << endmsg;

    ptr -> assign( 13, 0 );

    if ( race == "Nain" )
    {
        ptr -> at( 0u )  -= 5;   // corruption
        ptr -> at( 1u )  += 10;  // crochetage
        ptr -> at( 4u )  += 5;   // détection de la magie
        ptr -> at( 5u )  += 5;   // détection des illusions
        ptr -> at( 7u )  -= 10;  // escalade
        ptr -> at( 8u )  -= 5;   // lire des langues inconnues
        ptr -> at( 9u )  += 10;  // creuser des tunnels
        ptr -> at( 11u ) += 15;  // trouver et désamorcer les pièges
    }
    else if ( race == "Elfe" )
    {
        ptr -> at( 0u )  += 15;  // corruption
        ptr -> at( 1u )  -= 5;   // crochetage
        ptr -> at( 2u )  += 5;   // mouvement silencieux
        ptr -> at( 3u )  += 5;   // détection des bruits
        ptr -> at( 4u )  += 10;  // détection de la magie
        ptr -> at( 9u )  -= 10;  // creuser des tunnels
        ptr -> at( 10u ) += 10;  // se cacher dans l'ombre
        ptr -> at( 12u ) += 5;   // vol à la tire
    }
    else if ( race == "Gnome" )
    {
        ptr -> at( 0u )  += 5;   // corruption
        ptr -> at( 1u )  += 5;   // crochetage
        ptr -> at( 2u )  += 5;   // mouvement silencieux
        ptr -> at( 3u )  += 10;  // détection des bruits
        ptr -> at( 4u )  += 5;   // détection de la magie
        ptr -> at( 5u )  += 10;  // détection des illusions
        ptr -> at( 7u )  -= 15;  // escalade
        ptr -> at( 9u )  += 5;   // creuser des tunnels
        ptr -> at( 10u ) += 5;   // se cacher dans l'ombre
        ptr -> at( 11u ) += 10;  // trouver et désamorcer les pièges
    }
    else if ( race == "Demi-Elfe" )
    {
        ptr -> at( 0u )  += 5;   // corruption
        ptr -> at( 4u )  += 5;   // détection de la magie
        ptr -> at( 5u )  += 5;   // détection des illusions
        ptr -> at( 9u )  -= 5;   // creuser des tunnels
        ptr -> at( 10u ) += 5;   // se cacher dans l'ombre
        ptr -> at( 12u ) += 10;  // vol à la tire
    }
    else if ( race == "Demi-Orque" )
    {
        ptr -> at( 0u )  += 10;  // corruption
        ptr -> at( 3u )  += 5;   // détection des bruits
        ptr -> at( 5u )  -= 5;   // détection des illusions
        ptr -> at( 11u ) += 5;   // trouver et désamorcer les pièges
    }
    else if ( race == "Hobbit" )
    {
        ptr -> at( 1u )  += 5;   // crochetage
        ptr -> at( 2u )  += 10;  // mouvement silencieux
        ptr -> at( 3u )  += 5;   // détection des bruits
        ptr -> at( 4u )  += 5;   // détection de la magie
        ptr -> at( 6u )  += 10;  // évasion
        ptr -> at( 7u )  -= 15;  // escalade
        ptr -> at( 8u )  -= 5;   // lire des langues inconnues
        ptr -> at( 9u )  += 5;   // creuser des tunnels
        ptr -> at( 10u ) += 15;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 5;   // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 5;   // vol à la tire
    }

    switch( dext )
    {
    case 9:
        ptr -> at( 1u )  -= 10;  // crochetage
        ptr -> at( 2u )  -= 20;  // mouvement silencieux
        ptr -> at( 6u )  -= 15;  // évasion
        ptr -> at( 7u )  -= 10;  // escalade
        ptr -> at( 9u ) -= 10;  // creuser des tunnels
        ptr -> at( 10u ) -= 10;  // se cacher dans l'ombre
        ptr -> at( 11u ) -= 10;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) -= 15;  // vol à la tire
        break;
    case 10:
        ptr -> at( 1u )  -= 5;   // crochetage
        ptr -> at( 2u )  -= 15;  // mouvement silencieux
        ptr -> at( 6u )  -= 10;  // évasion
        ptr -> at( 7u )  -= 5;   // escalade
        ptr -> at( 9u )  -= 5;   // creuser des tunnels
        ptr -> at( 10u ) -= 5;   // se cacher dans l'ombre
        ptr -> at( 11u ) -= 10;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) -= 10;  // vol à la tire
        break;
    case 11:
        ptr -> at( 2u )  -= 10;  // mouvement silencieux
        ptr -> at( 6u )  -= 5;   // évasion
        ptr -> at( 11u ) -= 5;   // trouver et désamorcer les pièges
        ptr -> at( 12u ) -= 5;   // vol à la tire
        break;
    case 12:
        ptr -> at( 2u )  -= 5;   // mouvement silencieux
        break;
    case 16:
        ptr -> at( 1u )  += 5;   // crochetage
        break;
    case 17:
        ptr -> at( 1u )  += 10;  // crochetage
        ptr -> at( 2u )  += 5;   // mouvement silencieux
        ptr -> at( 6u )  += 5;   // évasion
        ptr -> at( 7u )  += 5;   // escalade
        ptr -> at( 10u ) += 5;   // se cacher dans l'ombre
        ptr -> at( 12u ) += 5;   // vol à la tire
        break;
    case 18:
        ptr -> at( 1u )  += 15;  // crochetage
        ptr -> at( 2u )  += 10;  // mouvement silencieux
        ptr -> at( 6u )  += 10;  // évasion
        ptr -> at( 7u )  += 10;  // escalade
        ptr -> at( 9u )  += 5;   // creuser des tunnels
        ptr -> at( 10u ) += 10;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 5;   // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 10;  // vol à la tire
        break;
    case 19:
        ptr -> at( 1u )  += 20;  // crochetage
        ptr -> at( 2u )  += 15;  // mouvement silencieux
        ptr -> at( 6u )  += 15;  // évasion
        ptr -> at( 7u )  += 15;  // escalade
        ptr -> at( 9u )  += 10;  // creuser des tunnels
        ptr -> at( 10u ) += 15;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 10;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 15;  // vol à la tire
        break;
    case 20:
        ptr -> at( 1u )  += 20;  // crochetage
        ptr -> at( 2u )  += 15;  // mouvement silencieux
        ptr -> at( 6u )  += 20;  // évasion
        ptr -> at( 7u )  += 20;  // escalade
        ptr -> at( 9u )  += 15;  // creuser des tunnels
        ptr -> at( 10u ) += 20;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 15;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 20;  // vol à la tire
        break;
    case 21:
        ptr -> at( 1u )  += 25;  // crochetage
        ptr -> at( 2u )  += 20;  // mouvement silencieux
        ptr -> at( 6u )  += 25;  // évasion
        ptr -> at( 7u )  += 20;  // escalade
        ptr -> at( 9u )  += 20;  // creuser des tunnels
        ptr -> at( 10u ) += 25;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 20;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 20;  // vol à la tire
        break;
    case 22:
        ptr -> at( 1u )  += 25;  // crochetage
        ptr -> at( 2u )  += 20;  // mouvement silencieux
        ptr -> at( 6u )  += 30;  // évasion
        ptr -> at( 7u )  += 25;  // escalade
        ptr -> at( 9u )  += 30;  // creuser des tunnels
        ptr -> at( 10u ) += 30;  // se cacher dans l'ombre
        ptr -> at( 11u ) += 20;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) += 25;  // vol à la tire
        break;
    }

    mess << FUNC << "determinerScoresAjustes -> fin" << endmsg;
}

void obtenirScoresBase( const unsigned& niveau, vector< unsigned >*& ptr )
{
    FlotMessage& mess = flotMessageGlobal();
    mess << FUNC << "obtenirScoresBase -> début" << endmsg;

    ptr -> assign(13, 0);

    switch( niveau )
    {
    case 1:
        // 30 que je dois répartir
        ptr -> at( 0u )  = 15;  // corruption - base 5
        ptr -> at( 1u )  = 25;  // crochetage
        ptr -> at( 2u )  = 15;  // mouvement silencieux
        ptr -> at( 3u )  = 10;  // détection des bruits
        ptr -> at( 4u )  = 10;  // détection de la magie - base 5
        ptr -> at( 5u )  = 15;  // détection des illusions - base 10
        ptr -> at( 6u )  = 15;  // évasion - base 10
        ptr -> at( 7u )  = 85;  // escalade
        ptr -> at( 8u )  =  0;  // lire des langues inconnues
        ptr -> at( 9u )  = 20;  // creuser des tunnels - base 15
        ptr -> at( 10u ) = 10;  // se cacher dans l'ombre
        ptr -> at( 11u ) = 20;  // trouver et désamorcer les pièges
        ptr -> at( 12u ) = 30;  // vol à la tire
        break;
    case 2:
        ptr -> at( 0u )  = 20;  // corruption
        ptr -> at( 1u )  = 29;
        ptr -> at( 2u )  = 21;
        ptr -> at( 3u )  = 10;
        ptr -> at( 4u )  = 10;  // détection de la magie
        ptr -> at( 5u )  = 15;  // détection des illusions
        ptr -> at( 6u )  = 20;  // évasion
        ptr -> at( 7u )  = 86;
        ptr -> at( 8u )  =  0;
        ptr -> at( 9u )  = 25;  // creuser des tunnels
        ptr -> at( 10u ) = 15;
        ptr -> at( 11u ) = 25;
        ptr -> at( 12u ) = 35;
        break;
    case 3:
        ptr -> at( 0u )  = 25;  // corruption
        ptr -> at( 1u )  = 33;
        ptr -> at( 2u )  = 27;
        ptr -> at( 3u )  = 15;
        ptr -> at( 4u )  = 15;  // détection de la magie
        ptr -> at( 5u )  = 20;  // détection des illusions
        ptr -> at( 6u )  = 25;  // évasion
        ptr -> at( 7u )  = 87;
        ptr -> at( 8u )  =  0;
        ptr -> at( 9u )  = 30;  // creuser des tunnels
        ptr -> at( 10u ) = 20;
        ptr -> at( 11u ) = 30;
        ptr -> at( 12u ) = 40;
        break;
    case 4:
        ptr -> at( 0u )  = 30;  // corruption
        ptr -> at( 1u )  = 37;
        ptr -> at( 2u )  = 33;
        ptr -> at( 3u )  = 15;
        ptr -> at( 4u )  = 15;  // détection de la magie
        ptr -> at( 5u )  = 20;  // détection des illusions
        ptr -> at( 6u )  = 30;  // évasion
        ptr -> at( 7u )  = 88;
        ptr -> at( 8u )  = 20;
        ptr -> at( 9u )  = 35;  // creuser des tunnels
        ptr -> at( 10u ) = 25;
        ptr -> at( 11u ) = 35;
        ptr -> at( 12u ) = 45;
        break;
    case 5:
        ptr -> at( 0u )  = 35;  // corruption
        ptr -> at( 1u )  = 42;
        ptr -> at( 2u )  = 40;
        ptr -> at( 3u )  = 20;
        ptr -> at( 4u )  = 20;  // détection de la magie
        ptr -> at( 5u )  = 25;  // détection des illusions
        ptr -> at( 6u )  = 35;  // évasion
        ptr -> at( 7u )  = 90;
        ptr -> at( 8u )  = 25;
        ptr -> at( 9u )  = 40;  // creuser des tunnels
        ptr -> at( 10u ) = 31;
        ptr -> at( 11u ) = 40;
        ptr -> at( 12u ) = 50;
        break;
    case 6:
        ptr -> at( 0u )  = 40;  // corruption
        ptr -> at( 1u )  = 47;
        ptr -> at( 2u )  = 47;
        ptr -> at( 3u )  = 20;
        ptr -> at( 4u )  = 20;  // détection de la magie
        ptr -> at( 5u )  = 25;  // détection des illusions
        ptr -> at( 6u )  = 40;  // évasion
        ptr -> at( 7u )  = 92;
        ptr -> at( 8u )  = 30;
        ptr -> at( 9u )  = 45;  // creuser des tunnels
        ptr -> at( 10u ) = 37;
        ptr -> at( 11u ) = 45;
        ptr -> at( 12u ) = 55;
        break;
    case 7:
        ptr -> at( 0u )  = 45;  // corruption
        ptr -> at( 1u )  = 52;
        ptr -> at( 2u )  = 55;
        ptr -> at( 3u )  = 25;
        ptr -> at( 4u )  = 25;  // détection de la magie
        ptr -> at( 5u )  = 30;  // détection des illusions
        ptr -> at( 6u )  = 45;  // évasion
        ptr -> at( 7u )  = 94;
        ptr -> at( 8u )  = 35;
        ptr -> at( 9u )  = 50;  // creuser des tunnels
        ptr -> at( 10u ) = 43;
        ptr -> at( 11u ) = 50;
        ptr -> at( 12u ) = 60;
        break;
    case 8:
        ptr -> at( 0u )  = 45;  // corruption
        ptr -> at( 1u )  = 57;
        ptr -> at( 2u )  = 62;
        ptr -> at( 3u )  = 25;
        ptr -> at( 4u )  = 25;  // détection de la magie
        ptr -> at( 5u )  = 30;  // détection des illusions
        ptr -> at( 6u )  = 55;  // évasion
        ptr -> at( 7u )  = 96;
        ptr -> at( 8u )  = 40;
        ptr -> at( 9u )  = 55;  // creuser des tunnels
        ptr -> at( 10u ) = 49;
        ptr -> at( 11u ) = 55;
        ptr -> at( 12u ) = 65;
        break;
    case 9:
        ptr -> at( 0u )  = 45;  // corruption
        ptr -> at( 1u )  = 62;
        ptr -> at( 2u )  = 70;
        ptr -> at( 3u )  = 30;
        ptr -> at( 4u )  = 30;  // détection de la magie
        ptr -> at( 5u )  = 35;  // détection des illusions
        ptr -> at( 6u )  = 60;  // évasion
        ptr -> at( 7u )  = 98;
        ptr -> at( 8u )  = 45;
        ptr -> at( 9u )  = 60;  // creuser des tunnels
        ptr -> at( 10u ) = 56;
        ptr -> at( 11u ) = 60;
        ptr -> at( 12u ) = 70;
        break;
    case 10:
        ptr -> at( 0u )  = 50;  // corruption
        ptr -> at( 1u )  = 67;
        ptr -> at( 2u )  = 78;
        ptr -> at( 3u )  = 30;
        ptr -> at( 4u )  = 30;  // détection de la magie
        ptr -> at( 5u )  = 35;  // détection des illusions
        ptr -> at( 6u )  = 70;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 50;
        ptr -> at( 9u )  = 65;  // creuser des tunnels
        ptr -> at( 10u ) = 63;
        ptr -> at( 11u ) = 65;
        ptr -> at( 12u ) = 80;
        break;
    case 11:
        ptr -> at( 0u )  = 55;  // corruption
        ptr -> at( 1u )  = 72;
        ptr -> at( 2u )  = 86;
        ptr -> at( 3u )  = 35;
        ptr -> at( 4u )  = 35;  // détection de la magie
        ptr -> at( 5u )  = 40;  // détection des illusions
        ptr -> at( 6u )  = 75;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 55;
        ptr -> at( 9u )  = 70;  // creuser des tunnels
        ptr -> at( 10u ) = 70;
        ptr -> at( 11u ) = 70;
        ptr -> at( 12u ) = 90;
        break;
    case 12:
        ptr -> at( 0u )  = 60;  // corruption
        ptr -> at( 1u )  = 77;
        ptr -> at( 2u )  = 94;
        ptr -> at( 3u )  = 35;
        ptr -> at( 4u )  = 35;  // détection de la magie
        ptr -> at( 5u )  = 40;  // détection des illusions
        ptr -> at( 6u )  = 80;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 60;
        ptr -> at( 9u )  = 75;  // creuser des tunnels
        ptr -> at( 10u ) = 77;
        ptr -> at( 11u ) = 75;
        ptr -> at( 12u ) = 95;
        break;
    case 13:
        ptr -> at( 0u )  = 65;  // corruption
        ptr -> at( 1u )  = 82;
        ptr -> at( 2u )  = 99;
        ptr -> at( 3u )  = 40;
        ptr -> at( 4u )  = 40;  // détection de la magie
        ptr -> at( 5u )  = 45;  // détection des illusions
        ptr -> at( 6u )  = 85;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 65;
        ptr -> at( 9u )  = 80;  // creuser des tunnels
        ptr -> at( 10u ) = 85;
        ptr -> at( 11u ) = 80;
        ptr -> at( 12u ) = 99;
        break;
    case 14:
        ptr -> at( 0u )  = 65;  // corruption
        ptr -> at( 1u )  = 87;
        ptr -> at( 2u )  = 99;
        ptr -> at( 3u )  = 40;
        ptr -> at( 4u )  = 40;  // détection de la magie
        ptr -> at( 5u )  = 45;  // détection des illusions
        ptr -> at( 6u )  = 90;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 70;
        ptr -> at( 9u )  = 85;  // creuser des tunnels
        ptr -> at( 10u ) = 93;
        ptr -> at( 11u ) = 85;
        ptr -> at( 12u ) = 99;
        break;
    case 15:
        ptr -> at( 0u )  = 70;  // corruption
        ptr -> at( 1u )  = 92;
        ptr -> at( 2u )  = 99;
        ptr -> at( 3u )  = 50;
        ptr -> at( 4u )  = 50;  // détection de la magie
        ptr -> at( 5u )  = 55;  // détection des illusions
        ptr -> at( 6u )  = 95;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 75;
        ptr -> at( 9u )  = 90;  // creuser des tunnels
        ptr -> at( 10u ) = 99;
        ptr -> at( 11u ) = 90;
        ptr -> at( 12u ) = 99;
        break;
    case 16:
        ptr -> at( 0u )  = 75;  // corruption
        ptr -> at( 1u )  = 97;
        ptr -> at( 2u )  = 99;
        ptr -> at( 3u )  = 50;
        ptr -> at( 4u )  = 50;  // détection de la magie
        ptr -> at( 5u )  = 55;  // détection des illusions
        ptr -> at( 6u )  = 99;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 80;
        ptr -> at( 9u )  = 95;  // creuser des tunnels
        ptr -> at( 10u ) = 99;
        ptr -> at( 11u ) = 95;
        ptr -> at( 12u ) = 99;
        break;
    default:
        ptr -> at( 0u )  = 80;  // corruption
        ptr -> at( 1u )  = 99;
        ptr -> at( 2u )  = 99;
        ptr -> at( 3u )  = 55;
        ptr -> at( 4u )  = 55;  // détection de la magie
        ptr -> at( 5u )  = 55;  // détection des illusions
        ptr -> at( 6u )  = 99;  // évasion
        ptr -> at( 7u )  = 99;
        ptr -> at( 8u )  = 80;
        ptr -> at( 9u )  = 99;  // creuser des tunnels
        ptr -> at( 10u ) = 99;
        ptr -> at( 11u ) = 99;
        ptr -> at( 12u ) = 99;
    }

    mess << FUNC << "obtenirScoresBase -> fin" << endmsg;
}

/** @} */
